#Admin for YouTube API
API_KEY = "AIzaSyBKb9YXkQrDixv7uB7BGfKKSoi0Nk4A1ag"

#Right Wing
DM_CHANNEL_ID = "UCw3fku0sH3qA3c3pZeJwdAw"
DE_CHANNEL_ID = "UCz8omIXCPabFEgblrC_VIfA"

#Centrist
BBC_CHANNEL_ID = "UC16niRr50-MSBwiO3YDb3RA"
FT_CHANNEL_ID = "UCoUxsWakJucWg46KW5RsvPw"

#Left Wing
TG_CHANNEL_ID = "UCIRYBXDze5krPDzAEOxFGVA"
TM_CHANNEL_ID = "UC3EmxrWVl7K8xBH_UVIWY4Q"


#Film & Animation
TPP_CHANNEL_ID = "UCFeUyPY6W8qX8w2o6oSiRmw"
PP_CHANNEL_ID = "UCAOtE1V7Ots4DjM8JLlrYgg"

#Gaming
TDM_CHANNEL_ID = "UCS5Oz6CHmeoF7vSad0qqXfw"
JLY_CHANNEL_ID = "UC0DZmkupLYwc0yDsfocLh0A"

#Lifestyle/How-to
DH_CHANNEL_ID = "UC0rDDvHM7u_7aWgAojSXl1Q"
TT_CHANNEL_ID = "UCGLDtG2tl0uG8P0eNstbLUA"

#Music
NC_CHANNEL_ID = "UC_aEa8K-EOJ3D6gOs7HcyNg"
CP_CHANNEL_ID = "UCDPM_n1atn2ijUwHd0NNRQw"

#Non-profit
TP_CHANNEL_ID = "UCW4MQYT4fh6yZbmUPhLFvqg"
EE_CHANNEL_ID = "UCVRrGAcUc7cblUzOhI1KfFg"

#People and Blogs
JL_CHANNEL_ID = "UC5Y1pPVNm-odhiubuRO1D6A"
SM_CHANNEL_ID = "UCh5mLn90vUaB1PbRRx_AiaA"

#Animals
KG_CHANNEL_ID = "UC_9EXcw4PlVlaklxx12cDqA"
OM_CHANNEL_ID = "UCejVe2sNPjjvfCXg35q_EQQ"

#Science
WB_CHANNEL_ID = "UCMiJRAwDNSNzuYeN2uWa0pA"
STM_CHANNEL_ID = "UCEIwxahdLz7bap-VDs9h35A"

#Sport
FF_CHANNEL_ID = "UCKvn9VBLAiLiYL4FFJHri6g"
ICC_CHANNEL_ID = "UCt2JXOLNxqry7B_4rRZME3Q"

#Travel
BB_CHANNEL_ID = "UCxDZs_ltFFvn0FDHT6kmoXA"
DP_CHANNEL_ID = "UCKygRpISlqs5TufcT3JtRng"

#Auto
CW_CHANNEL_ID = "UCUhFaUpnq31m6TNX2VKVSVA"
CT_CHANNEL_ID = "UCNBbCOuAN1NZAuj0vPe_MkA"

#Comedy
NN_CHANNEL_ID = "UCVjlpEjEY9GpksqbEesJnNA"
WN_CHANNEL_ID = "UCaFUrR3oSxOl5Y9y6tvLTEg"

#Education
JB_CHANNEL_ID = "UChUHOEe7zgYmrv7a_LlpNng"
MK_CHANNEL_ID = "UC1QqdFv5e9QSEi0eYdfwuqw"

#Entertainment
DR_CHANNEL_ID = "UC6D1L2vxEAg_Vi0JSxMBDgA"
BGT_CHANNEL_ID = "UCUtZaxDF3hD5VK4xRYFBePQ"

DM_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+DM_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
DM_response = requests.get(DM_url).json()

DE_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+DE_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
DE_response = requests.get(DE_url).json()

BBC_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+BBC_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
BBC_response = requests.get(BBC_url).json()

FT_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+FT_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
FT_response = requests.get(FT_url).json()

TG_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+TG_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
TG_response = requests.get(TG_url).json()

TM_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+TM_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
TM_response = requests.get(TM_url).json()

TPP_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+TPP_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
TPP_response = requests.get(TPP_url).json()

PP_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+PP_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
PP_response = requests.get(PP_url).json()

TDM_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+TDM_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
TDM_response = requests.get(TDM_url).json()

JLY_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+JLY_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
JLY_response = requests.get(JLY_url).json()

SM_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+SM_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
SM_response = requests.get(SM_url).json()

JL_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+JL_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
JL_response = requests.get(JL_url).json()

KG_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+KG_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
KG_response = requests.get(KG_url).json()

OM_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+OM_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
OM_response = requests.get(OM_url).json()

WB_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+WB_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
WB_response = requests.get(WB_url).json()

STM_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+STM_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
STM_response = requests.get(STM_url).json()

FF_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+FF_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
FF_response = requests.get(FF_url).json()

ICC_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+ICC_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
ICC_response = requests.get(ICC_url).json()

BB_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+BB_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
BB_response = requests.get(BB_url).json()

DP_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+DP_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
DP_response = requests.get(DP_url).json()

CW_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+CW_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
CW_response = requests.get(CW_url).json()

CT_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+CT_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
CT_response = requests.get(CT_url).json()

NN_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+NN_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
NN_response = requests.get(NN_url).json()

WN_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+WN_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
WN_response = requests.get(WN_url).json()

JB_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+JB_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
JB_response = requests.get(JB_url).json()

MK_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+MK_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
MK_response = requests.get(MK_url).json()

DR_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+DR_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
DR_response = requests.get(DR_url).json()

BGT_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+BGT_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
BGT_response = requests.get(BGT_url).json()

DH_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+DH_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
DH_response = requests.get(DH_url).json()

TT_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+TT_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
TT_response = requests.get(TT_url).json()

NC_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+NC_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
NC_response = requests.get(NC_url).json()

CP_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+CP_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
CP_response = requests.get(CP_url).json()

TP_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+TP_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
TP_response = requests.get(TP_url).json()

EE_url = "https://www.googleapis.com/youtube/v3/search?key="+API_KEY+"&channelId="+EE_CHANNEL_ID+"&part=snippet,id&order=date&maxResults=9"
EE_response = requests.get(EE_url).json()

#Obtaining Daily Mail's YouTube titles, joined together into long list.
DM_title_list = []
for video in DM_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        DM_titles = video['snippet']['title']
        DM_titles = str(DM_titles).replace("'"," ")
        DM_titles = str(DM_titles).replace("|"," ")
        DM_titles = DM_titles.encode('ascii', 'ignore')
        DM_titles = DM_titles.decode()
        DM_title_list.append(DM_titles)

#Obtaining The Daily Express's YouTube titles, joined together into long list.
DE_title_list = []
for video in DE_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        DE_titles = video['snippet']['title']
        DE_titles = str(DE_titles).replace("'"," ")
        DE_titles = str(DE_titles).replace("|"," ")
        DE_titles = str(DE_titles).replace("#shorts"," ")
        DE_titles = DE_titles.encode('ascii', 'ignore')
        DE_titles = DE_titles.decode()
        DE_title_list.append(DE_titles)
        
#Obtaining BBC's YouTube titles, joined together into long list.
BBC_title_list = []
for video in BBC_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        BBC_titles = video['snippet']['title']
        BBC_titles = str(BBC_titles).replace("'"," ")
        BBC_titles = str(BBC_titles).replace("|"," ")
        BBC_titles = str(BBC_titles).replace("– BBC News"," ")
        BBC_titles = str(BBC_titles).replace("- BBC News"," ")
        BBC_titles = str(BBC_titles).replace("#shorts"," ")
        BBC_titles = BBC_titles.encode('ascii', 'ignore')
        BBC_titles = BBC_titles.decode()
        BBC_title_list.append(BBC_titles)

#Obtaining FT's YouTube titles, joined together into long list.
FT_title_list = []
for video in FT_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        FT_titles = video['snippet']['title']
        FT_titles = str(FT_titles).replace("'"," ")
        FT_titles = str(FT_titles).replace("|"," ")
        FT_titles = str(FT_titles).replace("FT"," ")
        FT_titles = str(FT_titles).replace("#shorts"," ")
        FT_titles = FT_titles.encode('ascii', 'ignore')
        FT_titles = FT_titles.decode()
        FT_title_list.append(FT_titles)

#Obtaining The Guardian's YouTube titles, joined together into long list.
TG_title_list = []
for video in TG_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        TG_titles = video['snippet']['title']
        TG_titles = str(TG_titles).replace("'"," ")
        TG_titles = str(TG_titles).replace("|"," ")
        TG_titles = str(TG_titles).replace("#shorts"," ")
        TG_titles = TG_titles.encode('ascii', 'ignore')
        TG_titles = TG_titles.decode()
        TG_title_list.append(TG_titles)
        
#Obtaining TM's YouTube titles, joined together into long list.
TM_title_list = []
for video in TM_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        TM_titles = video['snippet']['title']
        TM_titles = str(TM_titles).replace("'"," ")
        TM_titles = str(TM_titles).replace("|"," ")
        TM_titles = str(TM_titles).replace("#shorts"," ")
        TM_titles = TM_titles.encode('ascii', 'ignore')
        TM_titles = TM_titles.decode()
        TM_title_list.append(TM_titles)
        
TPP_title_list = []
for video in TPP_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        TPP_titles = video['snippet']['title']
        TPP_titles = str(TPP_titles).replace("'"," ")
        TPP_titles = str(TPP_titles).replace("|"," ")
        TPP_titles = str(TPP_titles).replace("Pink Panther"," ")
        TPP_titles = str(TPP_titles).replace("35-Minute Compilation"," ")
        TPP_titles = TPP_titles.encode('ascii', 'ignore')
        TPP_titles = TPP_titles.decode()
        TPP_title_list.append(TPP_titles)

PP_title_list = []
for video in PP_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        PP_titles = video['snippet']['title']
        PP_titles = str(PP_titles).replace("'"," ")
        PP_titles = str(PP_titles).replace("|"," ")
        PP_titles = str(PP_titles).replace("Peppa Pig SPECIAL EPISODES"," ")
        PP_titles = str(PP_titles).replace("BRAND NEW SEASON 9 PEPPA"," ")
        PP_titles = PP_titles.encode('ascii', 'ignore')
        PP_titles = PP_titles.decode()
        PP_title_list.append(PP_titles)
        
TDM_title_list = []
for video in TDM_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        TDM_titles = video['snippet']['title']
        TDM_titles = str(TDM_titles).replace("'"," ")
        TDM_titles = str(TDM_titles).replace("|"," ")
        TDM_titles = str(TDM_titles).replace("#shorts"," ")
        TDM_titles = TDM_titles.encode('ascii', 'ignore')
        TDM_titles = TDM_titles.decode()
        TDM_title_list.append(TDM_titles)
        
JLY_title_list = []
for video in JLY_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        JLY_titles = video['snippet']['title']
        JLY_titles = str(JLY_titles).replace("'"," ")
        JLY_titles = str(JLY_titles).replace("|"," ")
        JLY_titles = str(JLY_titles).replace("#shorts"," ")
        JLY_titles = JLY_titles.encode('ascii', 'ignore')
        JLY_titles = JLY_titles.decode()
        JLY_title_list.append(JLY_titles)  
        
SM_title_list = []
for video in SM_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        SM_titles = video['snippet']['title']
        SM_titles = str(SM_titles).replace("'"," ")
        SM_titles = str(SM_titles).replace("|"," ")
        SM_titles = str(SM_titles).replace("#shorts"," ")
        SM_titles = SM_titles.encode('ascii', 'ignore')
        SM_titles = SM_titles.decode()
        SM_title_list.append(SM_titles)  
    
JL_title_list = []
for video in JL_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        JL_titles = video['snippet']['title']
        JL_titles = str(JL_titles).replace("'"," ")
        JL_titles = str(JL_titles).replace("|"," ")
        JL_titles = str(JL_titles).replace("#shorts"," ")
        JL_titles = JL_titles.encode('ascii', 'ignore')
        JL_titles = JL_titles.decode()
        JL_title_list.append(JL_titles) 
        
KG_title_list = []
for video in KG_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        KG_titles = video['snippet']['title']
        KG_titles = str(KG_titles).replace("'"," ")
        KG_titles = str(KG_titles).replace("|"," ")
        KG_titles = str(KG_titles).replace("#shorts"," ")
        KG_titles = KG_titles.encode('ascii', 'ignore')
        KG_titles = KG_titles.decode()
        KG_title_list.append(KG_titles) 
        
OM_title_list = []
for video in OM_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        OM_titles = video['snippet']['title']
        OM_titles = str(OM_titles).replace("'"," ")
        OM_titles = str(OM_titles).replace("|"," ")
        OM_titles = str(OM_titles).replace("1 Minute Animals"," ")
        OM_titles = OM_titles.encode('ascii', 'ignore')
        OM_titles = OM_titles.decode()
        OM_title_list.append(OM_titles) 
        
WB_title_list = []
for video in WB_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        WB_titles = video['snippet']['title']
        WB_titles = str(WB_titles).replace("'"," ")
        WB_titles = str(WB_titles).replace("|"," ")
        WB_titles = str(WB_titles).replace("#shorts"," ")
        WB_titles = WB_titles.encode('ascii', 'ignore')
        WB_titles = WB_titles.decode()
        WB_title_list.append(WB_titles) 
        
STM_title_list = []
for video in STM_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        STM_titles = video['snippet']['title']
        STM_titles = str(STM_titles).replace("'"," ")
        STM_titles = str(STM_titles).replace("|"," ")
        STM_titles = str(STM_titles).replace("#shorts"," ")
        STM_titles = STM_titles.encode('ascii', 'ignore')
        STM_titles = STM_titles.decode()
        STM_title_list.append(STM_titles) 
        
FF_title_list = []
for video in FF_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        FF_titles = video['snippet']['title']
        FF_titles = str(FF_titles).replace("'"," ")
        FF_titles = str(FF_titles).replace("|"," ")
        FF_titles = str(FF_titles).replace("#Shorts"," ")
        FF_titles = FF_titles.encode('ascii', 'ignore')
        FF_titles = FF_titles.decode()
        FF_title_list.append(FF_titles)

ICC_title_list = []
for video in ICC_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        ICC_titles = video['snippet']['title']
        ICC_titles = str(ICC_titles).replace("'"," ")
        ICC_titles = str(ICC_titles).replace("|"," ")
        ICC_titles = str(ICC_titles).replace("ICC Mens T20 World Cup Trophy Tour 2022"," ")
        ICC_titles = str(ICC_titles).replace("ICC Men s T20 World Cup Trophy Tour"," ")
        ICC_titles = str(ICC_titles).replace("ICC Men s T20 World Cup 2022"," ")
        ICC_titles = str(ICC_titles).replace("ICC Men s T20WC 2022"," ")
        ICC_titles = str(ICC_titles).replace("T20WC 2022"," ")
        ICC_titles = str(ICC_titles).replace("T20 World Cup 2022"," ")
        ICC_titles = str(ICC_titles).replace("The ICC Review"," ")
        ICC_titles = ICC_titles.encode('ascii', 'ignore')
        ICC_titles = ICC_titles.decode()
        ICC_title_list.append(ICC_titles)

BB_title_list = []
for video in BB_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        BB_titles = video['snippet']['title']
        BB_titles = str(BB_titles).replace("'"," ")
        BB_titles = str(BB_titles).replace("|"," ")
        BB_titles = str(BB_titles).replace("#shorts"," ")
        BB_titles = BB_titles.encode('ascii', 'ignore')
        BB_titles = BB_titles.decode()
        BB_title_list.append(BB_titles)

DP_title_list = []
for video in DP_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        DP_titles = video['snippet']['title']
        DP_titles = str(DP_titles).replace("'"," ")
        DP_titles = str(DP_titles).replace("|"," ")
        DP_titles = str(DP_titles).replace("#shorts"," ")
        DP_titles = DP_titles.encode('ascii', 'ignore')
        DP_titles = DP_titles.decode()
        DP_title_list.append(DP_titles)

CW_title_list = []
for video in CW_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        CW_titles = video['snippet']['title']
        CW_titles = str(CW_titles).replace("'"," ")
        CW_titles = str(CW_titles).replace("|"," ")
        CW_titles = str(CW_titles).replace("#shorts"," ")
        CW_titles = CW_titles.encode('ascii', 'ignore')
        CW_titles = CW_titles.decode()
        CW_title_list.append(CW_titles)       

CT_title_list = []
for video in CT_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        CT_titles = video['snippet']['title']
        CT_titles = str(CT_titles).replace("'"," ")
        CT_titles = str(CT_titles).replace("|"," ")
        CT_titles = str(CT_titles).replace("#shorts"," ")
        CT_titles = CT_titles.encode('ascii', 'ignore')
        CT_titles = CT_titles.decode()
        CT_title_list.append(CT_titles)
        
NN_title_list = []
for video in NN_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        NN_titles = video['snippet']['title']
        NN_titles = str(NN_titles).replace("'"," ")
        NN_titles = str(NN_titles).replace("|"," ")
        NN_titles = str(NN_titles).replace("Uncle Roger"," ")
        NN_titles = str(NN_titles).replace("UNCLE ROGER"," ")
        NN_titles = NN_titles.encode('ascii', 'ignore')
        NN_titles = NN_titles.decode()
        NN_title_list.append(NN_titles)  

WN_title_list = []
for video in WN_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        WN_titles = video['snippet']['title']
        WN_titles = str(WN_titles).replace("'"," ")
        WN_titles = str(WN_titles).replace("|"," ")
        WN_titles = str(WN_titles).replace("#shorts"," ")
        WN_titles = WN_titles.encode('ascii', 'ignore')
        WN_titles = WN_titles.decode()
        WN_title_list.append(WN_titles)  
        
JB_title_list = []
for video in JB_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        JB_titles = video['snippet']['title']
        JB_titles = str(JB_titles).replace("Jungle Beat: Munki & Trunk"," ")
        JB_titles = str(JB_titles).replace("Jungle Beat: Munki and Trunk"," ")
        JB_titles = str(JB_titles).replace("|"," ")
        JB_titles = str(JB_titles).replace("Kids Animation 2023"," ")
        JB_titles = str(JB_titles).replace("Kids Animation 2022"," ")
        JB_titles = str(JB_titles).replace("Jungle Beat: Munki and Trunk"," ")
        JB_titles = JB_titles.encode('ascii', 'ignore')
        JB_titles = JB_titles.decode()
        JB_title_list.append(JB_titles)

BGT_title_list = []
for video in BGT_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        BGT_titles = video['snippet']['title']
        BGT_titles = str(BGT_titles).replace("'"," ")
        BGT_titles = str(BGT_titles).replace("|"," ")
        BGT_titles = str(BGT_titles).replace("Britain s Got Talent"," ")
        BGT_titles = BGT_titles.encode('ascii', 'ignore')
        BGT_titles = BGT_titles.decode()
        BGT_title_list.append(BGT_titles)

MK_title_list = []
for video in MK_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        MK_titles = video['snippet']['title']
        MK_titles = str(MK_titles).replace("'"," ")
        MK_titles = str(MK_titles).replace("|"," ")
        MK_titles = str(MK_titles).replace("Nursery Rhymes"," ")
        MK_titles = str(MK_titles).replace("Sing Along"," ")
        MK_titles = str(MK_titles).replace("Kids Learn!"," ")
        MK_titles = MK_titles.encode('ascii', 'ignore')
        MK_titles = MK_titles.decode()
        MK_title_list.append(MK_titles)  
        
DR_title_list = []
for video in DR_response ['items']:
    if video ['id']['kind'] == "youtube#video":
        DR_titles = video['snippet']['title']
        DR_titles = str(DR_titles).replace("'"," ")
        DR_titles = str(DR_titles).replace("|"," ")
        DR_titles = str(DR_titles).replace("#shorts"," ")
        DR_titles = DR_titles.encode('ascii', 'ignore')
        DR_titles = DR_titles.decode()
        DR_title_list.append(DR_titles)

DH_title_list = []
for video in DH_response['items']:
    if video['id']['kind'] == "youtube#video":
        DH_titles = video['snippet']['title']
        DH_titles = str(DH_titles).replace("'", " ")
        DH_titles = str(DH_titles).replace("|", " ")
        DH_titles = str(DH_titles).replace("#shorts", " ")
        DH_titles = DH_titles.encode('ascii', 'ignore')
        DH_titles = DH_titles.decode()
        DH_title_list.append(DH_titles)
        
TT_title_list = []
for video in TT_response['items']:
    if video['id']['kind'] == "youtube#video":
        TT_titles = video['snippet']['title']
        TT_titles = str(TT_titles).replace("'", " ")
        TT_titles = str(TT_titles).replace("|", " ")
        TT_titles = str(TT_titles).replace("#shorts", " ")
        TT_titles = TT_titles.encode('ascii', 'ignore')
        TT_titles = TT_titles.decode()
        TT_title_list.append(TT_titles)

NC_title_list = []
for video in NC_response['items']:
    if video['id']['kind'] == "youtube#video":
        NC_titles = video['snippet']['title']
        NC_titles = str(NC_titles).replace("'", " ")
        NC_titles = str(NC_titles).replace("|", " ")
        NC_titles = str(NC_titles).replace("#shorts", " ")
        NC_titles = NC_titles.encode('ascii', 'ignore')
        NC_titles = NC_titles.decode()
        NC_title_list.append(NC_titles)

CP_title_list = []
for video in CP_response['items']:
    if video['id']['kind'] == "youtube#video":
        CP_titles = video['snippet']['title']
        CP_titles = str(CP_titles).replace("'", " ")
        CP_titles = str(CP_titles).replace("|", " ")
        CP_titles = str(CP_titles).replace("#shorts", " ")
        CP_titles = CP_titles.encode('ascii', 'ignore')
        CP_titles = CP_titles.decode()
        CP_title_list.append(CP_titles)
        
TP_title_list = []
for video in TP_response['items']:
    if video['id']['kind'] == "youtube#video":
        TP_titles = video['snippet']['title']
        TP_titles = str(TP_titles).replace("'", " ")
        TP_titles = str(TP_titles).replace("|", " ")
        TP_titles = str(TP_titles).replace("#shorts", " ")
        TP_titles = TP_titles.encode('ascii', 'ignore')
        TP_titles = TP_titles.decode()
        TP_title_list.append(TP_titles)

EE_title_list = []
for video in EE_response['items']:
    if video['id']['kind'] == "youtube#video":
        EE_titles = video['snippet']['title']
        EE_titles = str(EE_titles).replace("'", " ")
        EE_titles = str(EE_titles).replace("|", " ")
        EE_titles = str(EE_titles).replace("#shorts", " ")
        EE_titles = EE_titles.encode('ascii', 'ignore')
        EE_titles = EE_titles.decode()
        EE_title_list.append(EE_titles)

#Translating list of titles into string
DM_title_long_string = " ".join(DM_title_list)
DM_title_string_complete = DM_title_long_string.replace('Jungle Confidential', '')
DM_num_punctuation = len([token for token in DM_title_string_complete if token in punctuations])
DM_num_uppercase = len([word for word in DM_title_string_complete if word.isupper()])
DM_PROP_UPPER = DM_num_uppercase / len(DM_title_string_complete)
DM_tokenised_words = word_tokenize(DM_title_string_complete)
DM_lc_tokens = [i.lower() for i in DM_tokenised_words]
DM_lc_filtered_tokens = [word for word in DM_lc_tokens if word not in punctuations]
DM_lc_fully_filtered_tokens = [word for word in DM_lc_filtered_tokens if not word in stop_words]
DM_lemmatized_tokens = []
for token in DM_lc_fully_filtered_tokens:
    DM_lemmatized_tokens.append(lemmatizer.lemmatize(token))
    
#Translating list of titles into string
DE_title_string_complete = " ".join(DE_title_list)
DE_num_punctuation = len([token for token in DE_title_string_complete if token in punctuations])
DE_num_uppercase = len([word for word in DE_title_string_complete if word.isupper()])
DE_PROP_UPPER = DE_num_uppercase / len(DE_title_string_complete)
DE_tokenised_words = word_tokenize(DE_title_string_complete)
DE_lc_tokens = [i.lower() for i in DE_tokenised_words]
DE_lc_filtered_tokens = [word for word in DE_lc_tokens if word not in punctuations]
DE_lc_fully_filtered_tokens = [word for word in DE_lc_filtered_tokens if not word in stop_words]
DE_lemmatized_tokens = []
for token in DE_lc_fully_filtered_tokens:
    DE_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
BBC_title_string_complete = " ".join(BBC_title_list)
BBC_num_punctuation = len([token for token in BBC_title_string_complete if token in punctuations])
BBC_num_uppercase = len([word for word in BBC_title_string_complete if word.isupper()])
BBC_PROP_UPPER = BBC_num_uppercase / len(BBC_title_string_complete)
BBC_tokenised_words = word_tokenize(BBC_title_string_complete)
BBC_lc_tokens = [i.lower() for i in BBC_tokenised_words]
BBC_lc_filtered_tokens = [word for word in BBC_lc_tokens if word not in punctuations]
BBC_lc_fully_filtered_tokens = [word for word in BBC_lc_filtered_tokens if not word in stop_words]
BBC_lemmatized_tokens = []
for token in BBC_lc_fully_filtered_tokens:
    BBC_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
FT_title_string_complete = " ".join(FT_title_list)
FT_num_punctuation = len([token for token in FT_title_string_complete if token in punctuations])
FT_num_uppercase = len([word for word in FT_title_string_complete if word.isupper()])
FT_PROP_UPPER = FT_num_uppercase / len(FT_title_string_complete)
FT_tokenised_words = word_tokenize(FT_title_string_complete)
FT_lc_tokens = [i.lower() for i in FT_tokenised_words]
FT_lc_filtered_tokens = [word for word in FT_lc_tokens if word not in punctuations]
FT_lc_fully_filtered_tokens = [word for word in FT_lc_filtered_tokens if not word in stop_words]
FT_lemmatized_tokens = []
for token in FT_lc_fully_filtered_tokens:
    FT_lemmatized_tokens.append(lemmatizer.lemmatize(token))
    
#Translating list of titles into string
TG_title_long_string = " ".join(TG_title_list)
TG_num_punctuation = len([token for token in TG_title_long_string if token in punctuations])
TG_num_uppercase = len([word for word in TG_title_long_string if word.isupper()])
TG_PROP_UPPER = TG_num_uppercase / len(TG_title_long_string)
TG_tokenised_words = word_tokenize(TG_title_long_string)
TG_lc_tokens = [i.lower() for i in TG_tokenised_words]
TG_lc_filtered_tokens = [word for word in TG_lc_tokens if word not in punctuations]
TG_lc_fully_filtered_tokens = [word for word in TG_lc_filtered_tokens if not word in stop_words]
TG_lemmatized_tokens = []
for token in TG_lc_fully_filtered_tokens:
    TG_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
TM_title_long_string = " ".join(TM_title_list)
TM_num_punctuation = len([token for token in TM_title_long_string if token in punctuations])
TM_num_uppercase = len([word for word in TM_title_long_string if word.isupper()])
TM_PROP_UPPER = TM_num_uppercase / len(TM_title_long_string)
TM_tokenised_words = word_tokenize(TM_title_long_string)
TM_lc_tokens = [i.lower() for i in TM_tokenised_words]
TM_lc_filtered_tokens = [word for word in TM_lc_tokens if word not in punctuations]
TM_lc_fully_filtered_tokens = [word for word in TM_lc_filtered_tokens if not word in stop_words]
TM_lemmatized_tokens = []
for token in TM_lc_fully_filtered_tokens:
    TM_lemmatized_tokens.append(lemmatizer.lemmatize(token))
    
#Translating list of titles into string
TPP_title_long_string = " ".join(TPP_title_list)
TPP_num_punctuation = len([token for token in TPP_title_long_string if token in punctuations])
TPP_num_uppercase = len([word for word in TPP_title_long_string if word.isupper()])
TPP_PROP_UPPER = TPP_num_uppercase / len(TPP_title_long_string)
TPP_tokenised_words = word_tokenize(TPP_title_long_string)
TPP_lc_tokens = [i.lower() for i in TPP_tokenised_words]
TPP_lc_filtered_tokens = [word for word in TPP_lc_tokens if word not in punctuations]
TPP_lc_fully_filtered_tokens = [word for word in TPP_lc_filtered_tokens if not word in stop_words]
TPP_lemmatized_tokens = []
for token in TPP_lc_fully_filtered_tokens:
    TPP_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
PP_title_long_string = " ".join(PP_title_list)
PP_num_punctuation = len([token for token in PP_title_long_string if token in punctuations])
PP_num_uppercase = len([word for word in PP_title_long_string if word.isupper()])
PP_PROP_UPPER = PP_num_uppercase / len(PP_title_long_string)
PP_tokenised_words = word_tokenize(PP_title_long_string)
PP_lc_tokens = [i.lower() for i in PP_tokenised_words]
PP_lc_filtered_tokens = [word for word in PP_lc_tokens if word not in punctuations]
PP_lc_fully_filtered_tokens = [word for word in PP_lc_filtered_tokens if not word in stop_words]
PP_lemmatized_tokens = []
for token in PP_lc_fully_filtered_tokens:
    PP_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
TDM_title_long_string = " ".join(TDM_title_list)
TDM_num_punctuation = len([token for token in TDM_title_long_string if token in punctuations])
TDM_num_uppercase = len([word for word in TDM_title_long_string if word.isupper()])
TDM_PROP_UPPER = TDM_num_uppercase / len(TDM_title_long_string)
TDM_tokenised_words = word_tokenize(TDM_title_long_string)
TDM_lc_tokens = [i.lower() for i in TDM_tokenised_words]
TDM_lc_filtered_tokens = [word for word in TDM_lc_tokens if word not in punctuations]
TDM_lc_fully_filtered_tokens = [word for word in TDM_lc_filtered_tokens if not word in stop_words]
TDM_lemmatized_tokens = []
for token in TDM_lc_fully_filtered_tokens:
    TDM_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
JLY_title_long_string = " ".join(JLY_title_list)
JLY_num_punctuation = len([token for token in JLY_title_long_string if token in punctuations])
JLY_num_uppercase = len([word for word in JLY_title_long_string if word.isupper()])
JLY_PROP_UPPER = JLY_num_uppercase / len(JLY_title_long_string)
JLY_tokenised_words = word_tokenize(JLY_title_long_string)
JLY_lc_tokens = [i.lower() for i in JLY_tokenised_words]
JLY_lc_filtered_tokens = [word for word in JLY_lc_tokens if word not in punctuations]
JLY_lc_fully_filtered_tokens = [word for word in JLY_lc_filtered_tokens if not word in stop_words]
JLY_lemmatized_tokens = []
for token in JLY_lc_fully_filtered_tokens:
    JLY_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
SM_title_long_string = " ".join(SM_title_list)
SM_num_punctuation = len([token for token in SM_title_long_string if token in punctuations])
SM_num_uppercase = len([word for word in SM_title_long_string if word.isupper()])
SM_PROP_UPPER = SM_num_uppercase / len(SM_title_long_string)
SM_tokenised_words = word_tokenize(SM_title_long_string)
SM_lc_tokens = [i.lower() for i in SM_tokenised_words]
SM_lc_filtered_tokens = [word for word in SM_lc_tokens if word not in punctuations]
SM_lc_fully_filtered_tokens = [word for word in SM_lc_filtered_tokens if not word in stop_words]
SM_lemmatized_tokens = []
for token in SM_lc_fully_filtered_tokens:
    SM_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
JL_title_long_string = " ".join(JL_title_list)
JL_num_punctuation = len([token for token in JL_title_long_string if token in punctuations])
JL_num_uppercase = len([word for word in JL_title_long_string if word.isupper()])
JL_PROP_UPPER = JL_num_uppercase / len(JL_title_long_string)
JL_tokenised_words = word_tokenize(JL_title_long_string)
JL_lc_tokens = [i.lower() for i in JL_tokenised_words]
JL_lc_filtered_tokens = [word for word in JL_lc_tokens if word not in punctuations]
JL_lc_fully_filtered_tokens = [word for word in JL_lc_filtered_tokens if not word in stop_words]
JL_lemmatized_tokens = []
for token in JL_lc_fully_filtered_tokens:
    JL_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
KG_title_long_string = " ".join(KG_title_list)
KG_num_punctuation = len([token for token in KG_title_long_string if token in punctuations])
KG_num_uppercase = len([word for word in KG_title_long_string if word.isupper()])
KG_PROP_UPPER = KG_num_uppercase / len(KG_title_long_string)
KG_tokenised_words = word_tokenize(KG_title_long_string)
KG_lc_tokens = [i.lower() for i in KG_tokenised_words]
KG_lc_filtered_tokens = [word for word in KG_lc_tokens if word not in punctuations]
KG_lc_fully_filtered_tokens = [word for word in KG_lc_filtered_tokens if not word in stop_words]
KG_lemmatized_tokens = []
for token in KG_lc_fully_filtered_tokens:
    KG_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
OM_title_long_string = " ".join(OM_title_list)
OM_num_punctuation = len([token for token in OM_title_long_string if token in punctuations])
OM_num_uppercase = len([word for word in OM_title_long_string if word.isupper()])
OM_PROP_UPPER = OM_num_uppercase / len(OM_title_long_string)
OM_tokenised_words = word_tokenize(OM_title_long_string)
OM_lc_tokens = [i.lower() for i in OM_tokenised_words]
OM_lc_filtered_tokens = [word for word in OM_lc_tokens if word not in punctuations]
OM_lc_fully_filtered_tokens = [word for word in OM_lc_filtered_tokens if not word in stop_words]
OM_lemmatized_tokens = []
for token in OM_lc_fully_filtered_tokens:
    OM_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
WB_title_long_string = " ".join(WB_title_list)
WB_num_punctuation = len([token for token in WB_title_long_string if token in punctuations])
WB_num_uppercase = len([word for word in WB_title_long_string if word.isupper()])
WB_PROP_UPPER = WB_num_uppercase / len(WB_title_long_string)
WB_tokenised_words = word_tokenize(WB_title_long_string)
WB_lc_tokens = [i.lower() for i in WB_tokenised_words]
WB_lc_filtered_tokens = [word for word in WB_lc_tokens if word not in punctuations]
WB_lc_fully_filtered_tokens = [word for word in WB_lc_filtered_tokens if not word in stop_words]
WB_lemmatized_tokens = []
for token in WB_lc_fully_filtered_tokens:
    WB_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
STM_title_long_string = " ".join(STM_title_list)
STM_num_punctuation = len([token for token in STM_title_long_string if token in punctuations])
STM_num_uppercase = len([word for word in STM_title_long_string if word.isupper()])
STM_PROP_UPPER = STM_num_uppercase / len(STM_title_long_string)
STM_tokenised_words = word_tokenize(STM_title_long_string)
STM_lc_tokens = [i.lower() for i in STM_tokenised_words]
STM_lc_filtered_tokens = [word for word in STM_lc_tokens if word not in punctuations]
STM_lc_fully_filtered_tokens = [word for word in STM_lc_filtered_tokens if not word in stop_words]
STM_lemmatized_tokens = []
for token in STM_lc_fully_filtered_tokens:
    STM_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
FF_title_long_string = " ".join(FF_title_list)
FF_num_punctuation = len([token for token in FF_title_long_string if token in punctuations])
FF_num_uppercase = len([word for word in FF_title_long_string if word.isupper()])
FF_PROP_UPPER = FF_num_uppercase / len(FF_title_long_string)
FF_tokenised_words = word_tokenize(FF_title_long_string)
FF_lc_tokens = [i.lower() for i in FF_tokenised_words]
FF_lc_filtered_tokens = [word for word in FF_lc_tokens if word not in punctuations]
FF_lc_fully_filtered_tokens = [word for word in FF_lc_filtered_tokens if not word in stop_words]
FF_lemmatized_tokens = []
for token in FF_lc_fully_filtered_tokens:
    FF_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
ICC_title_long_string = " ".join(ICC_title_list)
ICC_num_punctuation = len([token for token in ICC_title_long_string if token in punctuations])
ICC_num_uppercase = len([word for word in ICC_title_long_string if word.isupper()])
ICC_PROP_UPPER = ICC_num_uppercase / len(ICC_title_long_string)
ICC_tokenised_words = word_tokenize(ICC_title_long_string)
ICC_lc_tokens = [i.lower() for i in ICC_tokenised_words]
ICC_lc_filtered_tokens = [word for word in ICC_lc_tokens if word not in punctuations]
ICC_lc_fully_filtered_tokens = [word for word in ICC_lc_filtered_tokens if not word in stop_words]
ICC_lemmatized_tokens = []
for token in ICC_lc_fully_filtered_tokens:
    ICC_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
BB_title_long_string = " ".join(BB_title_list)
BB_num_punctuation = len([token for token in BB_title_long_string if token in punctuations])
BB_num_uppercase = len([word for word in BB_title_long_string if word.isupper()])
BB_PROP_UPPER = BB_num_uppercase / len(BB_title_long_string)
BB_tokenised_words = word_tokenize(BB_title_long_string)
BB_lc_tokens = [i.lower() for i in BB_tokenised_words]
BB_lc_filtered_tokens = [word for word in BB_lc_tokens if word not in punctuations]
BB_lc_fully_filtered_tokens = [word for word in BB_lc_filtered_tokens if not word in stop_words]
BB_lemmatized_tokens = []
for token in BB_lc_fully_filtered_tokens:
    BB_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
DP_title_long_string = " ".join(DP_title_list)
DP_num_punctuation = len([token for token in DP_title_long_string if token in punctuations])
DP_num_uppercase = len([word for word in DP_title_long_string if word.isupper()])
DP_PROP_UPPER = DP_num_uppercase / len(DP_title_long_string)
DP_tokenised_words = word_tokenize(DP_title_long_string)
DP_lc_tokens = [i.lower() for i in DP_tokenised_words]
DP_lc_filtered_tokens = [word for word in DP_lc_tokens if word not in punctuations]
DP_lc_fully_filtered_tokens = [word for word in DP_lc_filtered_tokens if not word in stop_words]
DP_lemmatized_tokens = []
for token in DP_lc_fully_filtered_tokens:
    DP_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
CW_title_long_string = " ".join(CW_title_list)
CW_num_punctuation = len([token for token in CW_title_long_string if token in punctuations])
CW_num_uppercase = len([word for word in CW_title_long_string if word.isupper()])
CW_PROP_UPPER = CW_num_uppercase / len(CW_title_long_string)
CW_tokenised_words = word_tokenize(CW_title_long_string)
CW_lc_tokens = [i.lower() for i in CW_tokenised_words]
CW_lc_filtered_tokens = [word for word in CW_lc_tokens if word not in punctuations]
CW_lc_fully_filtered_tokens = [word for word in CW_lc_filtered_tokens if not word in stop_words]
CW_lemmatized_tokens = []
for token in CW_lc_fully_filtered_tokens:
    CW_lemmatized_tokens.append(lemmatizer.lemmatize(token))

#Translating list of titles into string
CT_title_long_string = " ".join(CT_title_list)
CT_num_punctuation = len([token for token in CT_title_long_string if token in punctuations])
CT_num_uppercase = len([word for word in CT_title_long_string if word.isupper()])
CT_PROP_UPPER = CT_num_uppercase / len(CT_title_long_string)
CT_tokenised_words = word_tokenize(CT_title_long_string)
CT_lc_tokens = [i.lower() for i in CT_tokenised_words]
CT_lc_filtered_tokens = [word for word in CT_lc_tokens if word not in punctuations]
CT_lc_fully_filtered_tokens = [word for word in CT_lc_filtered_tokens if not word in stop_words]
CT_lemmatized_tokens = []
for token in CT_lc_fully_filtered_tokens:
    CT_lemmatized_tokens.append(lemmatizer.lemmatize(token))

NN_title_long_string = " ".join(NN_title_list)
NN_num_punctuation = len([token for token in NN_title_long_string if token in punctuations])
NN_num_uppercase = len([word for word in NN_title_long_string if word.isupper()])
NN_PROP_UPPER = NN_num_uppercase / len(NN_title_long_string)
NN_tokenised_words = word_tokenize(NN_title_long_string)
NN_lc_tokens = [i.lower() for i in NN_tokenised_words]
NN_lc_filtered_tokens = [word for word in NN_lc_tokens if word not in punctuations]
NN_lc_fully_filtered_tokens = [word for word in NN_lc_filtered_tokens if not word in stop_words]
NN_lemmatized_tokens = []
for token in NN_lc_fully_filtered_tokens:
    NN_lemmatized_tokens.append(lemmatizer.lemmatize(token))

WN_title_long_string = " ".join(WN_title_list)
WN_num_punctuation = len([token for token in WN_title_long_string if token in punctuations])
WN_num_uppercase = len([word for word in WN_title_long_string if word.isupper()])
WN_PROP_UPPER = WN_num_uppercase / len(WN_title_long_string)
WN_tokenised_words = word_tokenize(WN_title_long_string)
WN_lc_tokens = [i.lower() for i in WN_tokenised_words]
WN_lc_filtered_tokens = [word for word in WN_lc_tokens if word not in punctuations]
WN_lc_fully_filtered_tokens = [word for word in WN_lc_filtered_tokens if not word in stop_words]
WN_lemmatized_tokens = []
for token in WN_lc_fully_filtered_tokens:
    WN_lemmatized_tokens.append(lemmatizer.lemmatize(token))

JB_title_long_string = " ".join(JB_title_list)
JB_num_punctuation = len([token for token in JB_title_long_string if token in punctuations])
JB_num_uppercase = len([word for word in JB_title_long_string if word.isupper()])
JB_PROP_UPPER = JB_num_uppercase / len(JB_title_long_string)
JB_tokenised_words = word_tokenize(JB_title_long_string)
JB_lc_tokens = [i.lower() for i in JB_tokenised_words]
JB_lc_filtered_tokens = [word for word in JB_lc_tokens if word not in punctuations]
JB_lc_fully_filtered_tokens = [word for word in JB_lc_filtered_tokens if not word in stop_words]
JB_lemmatized_tokens = []
for token in JB_lc_fully_filtered_tokens:
    JB_lemmatized_tokens.append(lemmatizer.lemmatize(token))

MK_title_long_string = " ".join(MK_title_list)
MK_num_punctuation = len([token for token in MK_title_long_string if token in punctuations])
MK_num_uppercase = len([word for word in MK_title_long_string if word.isupper()])
MK_PROP_UPPER = MK_num_uppercase / len(MK_title_long_string)
MK_tokenised_words = word_tokenize(MK_title_long_string)
MK_lc_tokens = [i.lower() for i in MK_tokenised_words]
MK_lc_filtered_tokens = [word for word in MK_lc_tokens if word not in punctuations]
MK_lc_fully_filtered_tokens = [word for word in MK_lc_filtered_tokens if not word in stop_words]
MK_lemmatized_tokens = []
for token in MK_lc_fully_filtered_tokens:
    MK_lemmatized_tokens.append(lemmatizer.lemmatize(token))

DR_title_long_string = " ".join(DR_title_list)
DR_num_punctuation = len([token for token in DR_title_long_string if token in punctuations])
DR_num_uppercase = len([word for word in DR_title_long_string if word.isupper()])
DR_PROP_UPPER = DR_num_uppercase / len(DR_title_long_string)
DR_tokenised_words = word_tokenize(DR_title_long_string)
DR_lc_tokens = [i.lower() for i in DR_tokenised_words]
DR_lc_filtered_tokens = [word for word in DR_lc_tokens if word not in punctuations]
DR_lc_fully_filtered_tokens = [word for word in DR_lc_filtered_tokens if not word in stop_words]
DR_lemmatized_tokens = []
for token in DR_lc_fully_filtered_tokens:
    DR_lemmatized_tokens.append(lemmatizer.lemmatize(token))

BGT_title_long_string = " ".join(BGT_title_list)
BGT_num_punctuation = len([token for token in BGT_title_long_string if token in punctuations])
BGT_num_uppercase = len([word for word in BGT_title_long_string if word.isupper()])
BGT_PROP_UPPER = BGT_num_uppercase / len(BGT_title_long_string)
BGT_tokenised_words = word_tokenize(BGT_title_long_string)
BGT_lc_tokens = [i.lower() for i in BGT_tokenised_words]
BGT_lc_filtered_tokens = [word for word in BGT_lc_tokens if word not in punctuations]
BGT_lc_fully_filtered_tokens = [word for word in BGT_lc_filtered_tokens if not word in stop_words]
BGT_lemmatized_tokens = []
for token in BGT_lc_fully_filtered_tokens:
    BGT_lemmatized_tokens.append(lemmatizer.lemmatize(token))
    
DH_title_long_string = " ".join(DH_title_list)
DH_num_punctuation = len([token for token in DH_title_long_string if token in punctuations])
DH_num_uppercase = len([word for word in DH_title_long_string if word.isupper()])
DH_PROP_UPPER = DH_num_uppercase / len(DH_title_long_string)
DH_tokenised_words = word_tokenize(DH_title_long_string)
DH_lc_tokens = [i.lower() for i in DH_tokenised_words]
DH_lc_filtered_tokens = [word for word in DH_lc_tokens if word not in punctuations]
DH_lc_fully_filtered_tokens = [word for word in DH_lc_filtered_tokens if not word in stop_words]
DH_lemmatized_tokens = []
for token in DH_lc_fully_filtered_tokens:
    DH_lemmatized_tokens.append(lemmatizer.lemmatize(token))

TT_title_long_string = " ".join(TT_title_list)
TT_num_punctuation = len([token for token in TT_title_long_string if token in punctuations])
TT_num_uppercase = len([word for word in TT_title_long_string if word.isupper()])
TT_PROP_UPPER = TT_num_uppercase / len(TT_title_long_string)
TT_tokenised_words = word_tokenize(TT_title_long_string)
TT_lc_tokens = [i.lower() for i in TT_tokenised_words]
TT_lc_filtered_tokens = [word for word in TT_lc_tokens if word not in punctuations]
TT_lc_fully_filtered_tokens = [word for word in TT_lc_filtered_tokens if not word in stop_words]
TT_lemmatized_tokens = []
for token in TT_lc_fully_filtered_tokens:
    TT_lemmatized_tokens.append(lemmatizer.lemmatize(token))

NC_title_long_string = " ".join(NC_title_list)
NC_num_punctuation = len([token for token in NC_title_long_string if token in punctuations])
NC_num_uppercase = len([word for word in NC_title_long_string if word.isupper()])
NC_PROP_UPPER = NC_num_uppercase / len(NC_title_long_string)
NC_tokenised_words = word_tokenize(NC_title_long_string)
NC_lc_tokens = [i.lower() for i in NC_tokenised_words]
NC_lc_filtered_tokens = [word for word in NC_lc_tokens if word not in punctuations]
NC_lc_fully_filtered_tokens = [word for word in NC_lc_filtered_tokens if not word in stop_words]
NC_lemmatized_tokens = []
for token in NC_lc_fully_filtered_tokens:
    NC_lemmatized_tokens.append(lemmatizer.lemmatize(token))
    
CP_title_long_string = " ".join(CP_title_list)
CP_num_punctuation = len([token for token in CP_title_long_string if token in punctuations])
CP_num_uppercase = len([word for word in CP_title_long_string if word.isupper()])
CP_PROP_UPPER = CP_num_uppercase / len(CP_title_long_string)
CP_tokenised_words = word_tokenize(CP_title_long_string)
CP_lc_tokens = [i.lower() for i in CP_tokenised_words]
CP_lc_filtered_tokens = [word for word in CP_lc_tokens if word not in punctuations]
CP_lc_fully_filtered_tokens = [word for word in CP_lc_filtered_tokens if not word in stop_words]
CP_lemmatized_tokens = []
for token in CP_lc_fully_filtered_tokens:
    CP_lemmatized_tokens.append(lemmatizer.lemmatize(token))
    
TP_title_long_string = " ".join(TP_title_list)
TP_num_punctuation = len([token for token in TP_title_long_string if token in punctuations])
TP_num_uppercase = len([word for word in TP_title_long_string if word.isupper()])
TP_PROP_UPPER = TP_num_uppercase / len(TP_title_long_string)
TP_tokenised_words = word_tokenize(TP_title_long_string)
TP_lc_tokens = [i.lower() for i in TP_tokenised_words]
TP_lc_filtered_tokens = [word for word in TP_lc_tokens if word not in punctuations]
TP_lc_fully_filtered_tokens = [word for word in TP_lc_filtered_tokens if not word in stop_words]
TP_lemmatized_tokens = []
for token in TP_lc_fully_filtered_tokens:
    TP_lemmatized_tokens.append(lemmatizer.lemmatize(token))

EE_title_long_string = " ".join(EE_title_list)
EE_num_punctuation = len([token for token in EE_title_long_string if token in punctuations])
EE_num_uppercase = len([word for word in EE_title_long_string if word.isupper()])
EE_PROP_UPPER = EE_num_uppercase / len(EE_title_long_string)
EE_tokenised_words = word_tokenize(EE_title_long_string)
EE_lc_tokens = [i.lower() for i in EE_tokenised_words]
EE_lc_filtered_tokens = [word for word in EE_lc_tokens if word not in punctuations]
EE_lc_fully_filtered_tokens = [word for word in EE_lc_filtered_tokens if not word in stop_words]
EE_lemmatized_tokens = []
for token in EE_lc_fully_filtered_tokens:
    EE_lemmatized_tokens.append(lemmatizer.lemmatize(token))